The problem of tight coupling in C# and its solution using dependency injection
टाइट कपलिंग की समस्या और समाधान
जब एक क्लास दूसरे क्लास का उपयोग करता है तो जो क्लास उपयोग करता है अगर वही क्लास उस दूसरे क्लास का निर्माण करता है तो यहां टाइट कपलिंग की समस्या उत्पन्न होती है। जिस क्लास का उपयोग किया जा रहा है यदि उसके भीतर किसी प्रकार का परिवर्तन हो जाए तो क्लास को उपयोग करने वाले क्लास के भीतर समस्या उत्पन्न हो जाती है।
इस बात को सी शार्प प्रोग्रामिंग के अंतर्गत एक उदाहरण से समझ सकते हैं। आइए टाइट कपलिंग की समस्या को एक उदाहरण के माध्यम से समझने की कोशिश करते हैं:
मान लें कि हमारे पास एक कार क्लास है जो एक वाहन का प्रतिनिधित्व करती है, और एक इंजन क्लास है जो कार के इंजन का प्रतिनिधित्व करती है।
namespace TightCouplingDemo
{
public class Engine
{
public void Start()
{
Console.WriteLine("The engine has started.");
}
public void Stop()
{
Console.WriteLine("The engine has stopped.");
}
}
public class Car
{
private Engine engine; // Engine as dependency
public Car()
{
engine = new Engine(); // Car class constructs the Engine class
}
public void StartCar()
{
engine.Start();
Console.WriteLine("The car has started.");
}
public void StopCar()
{
engine.Stop();
Console.WriteLine("The car has stopped.");
}
}
}
💣इस उदाहरण में, कार क्लास इंजन क्लास का उपयोग करती है और इंजन क्लास का निर्माण भी करती है। यह एक टाइट कपलिंग की समस्या है, क्योंकि कार क्लास इंजन क्लास के बारे में जानती है और इसका निर्माण भी करती है।
अब, यदि हमें इंजन क्लास में कुछ बदलाव करना है, जैसे कि इसके कंस्ट्रक्टर में कुछ पैरामीटर जोड़ना, तो हमें कार क्लास में भी बदलाव करना होगा। अन्यथा त्रुटि - "इंजन कन्स्ट्रक्टर को पैरामीटर की आवश्यकता है" दिखाई देगा
namespace TightCouplingDemo
{
public class Engine
{
public Engine(int horsepower)
{
// Setting engine characteristics based on horsepower
}
// Methods same as before
}
public class Car
{
private Engine engine;
public Car()
{
engine = new Engine(); // Error - Engine constructor requires an integer parameter
}
// Methods same as before
}
}
अब, कार क्लास में भी बदलाव करना होगा:
public class Car
{
private Engine engine;
public Car(int horsepower)
{
engine = new Engine(horsepower); // No Error after change
}
// Methods same as before
}
टाइट कपलिंग की समस्या से निजात
इस प्रकार, टाइट कपलिंग की समस्या के कारण, एक क्लास में बदलाव करने से दूसरे क्लास पर भी प्रभाव पड़ता है। इस समस्या का समाधान करने के लिए, हमें डिपेंडेंसी इंजेक्शन का उपयोग करना चाहिए, जिससे एक क्लास दूसरे क्लास का निर्माण न करे, बल्कि इसके बजाय इसे बाहर से प्राप्त करे।
टाइट कपलिंग की समस्या से निजात पाने के लिए आईए देखते हैं कि किस प्रकार डिपेंडेंसी इंजेक्शन का उपयोग किया जाता है इसके लिए हम पिछले उदाहरण कार और इंजन का ही यूज करेंगे, डिपेंडेंसी इंजेक्शन का उपयोग करके टाइट कपलिंग की समस्या का समाधान करने के लिए.
हम पिछले उदाहरण को इस प्रकार बदल सकते हैं:
namespace TightCouplingDemo
{
public interface IEngine // 💚इंटरफ़ेस ही वह समाधान की कुंजी है
{
void Start();
void Stop();
}
public class Engine : IEngine
{
public void Start()
{
Console.WriteLine("The engine has started.");
}
public void Stop()
{
Console.WriteLine("The engine has stopped.");
}
}
public class Car
{
private IEngine engine;
public Car(IEngine engine) // Getting the engine through dependency injection
{
this.engine = engine;
}
public void StartCar()
{
engine.Start();
Console.WriteLine("The car has started.");
}
public void StopCar()
{
engine.Stop();
Console.WriteLine("The car has stopped.");
}
}
}
👉ध्यान दीजिए कि इंजन का निर्माण अब कार द्वारा स्वयं नहीं हो रहा बल्कि उसको कन्स्ट्रक्टर पैरामीटर के रूप में पास किया जा रहा है. साथ ही अब, इंजन class को IEngine इंटरफ़ेस को कार्यान्वित(Implement) करना होगा जिस क्लास को इंजन ऑब्जेक्ट की आवश्यकता होगी उसके कन्स्ट्रक्टर में IEngine इंटरफ़ेस को कन्स्ट्रक्टर पैरामीटर के रूप में पास करना होगा। इसी तरह दुसरे इंजन के प्रकार भी जो Engine के subtype हैं वे IEngine इंटरफ़ेस को इम्प्लेमेंट करेंगे
public class PetrolEngine : IEngine
{
public void Start()
{
Console.WriteLine("The petrol engine has started.");
}
public void Stop()
{
Console.WriteLine("The petrol engine has stopped.");
}
}
public class DieselEngine : IEngine
{
public void Start()
{
Console.WriteLine("The diesel engine has started.");
}
}
अब, हम कार क्लास का उपयोग करने के लिए इंजन क्लास का एक उदाहरण बना सकते हैं और इसे कार क्लास के कंस्ट्रक्टर में पास कर सकते हैं:
class Program
{
static void Main(string[] args)
{
IEngine engine = new Engine();
Car car = new Car(engine);
Car.startCar();
Car.stopCar();
IEngine pengine = new PetrolEngine();
Car car = new Car(pengine);
Car.startCar();
Car.stopCar();
}
}
👉ध्यान दीजिए कि इंजन का निर्माण क्लाइंट क्लास Program द्वारा हो रहा है न की Car द्वारा। इस प्रकार, डिपेंडेंसी इंजेक्शन का उपयोग करके, हमने टाइट कपलिंग की समस्या का समाधान किया है और कार क्लास को अधिक लचीला और मेन्टेनेबल बनाया है। अब, हम कार क्लास के साथ विभिन्न प्रकार के इंजन का उपयोग कर सकते हैं बिना इसके कोड को बदले।
टिप्पणियाँ
एक टिप्पणी भेजें